﻿//#include<iostream>
//
//using namespace std;

//class Student
//{
//	//成员变量
//	string name;	//姓名
//	int Chinese;	//语文成绩
//	int Math;		//数学成绩
//	int English;	//英语成绩
//
//	//成员函数
//	int total(int Chinese, int Math, int English)	//总成绩
//	{
//		return Chinese + Math + English;
//	}
//};
//
//int main()
//{
//	Student stu;
//
//	cout << stu.total(100, 200, 300) << endl;
//
//	return 0;
//}



//class Stack
//{
//public:
//	// 成员函数
//
//	void Init(int n = 4)
//	{
//		a = (int*)malloc(sizeof(int) * n);
//		capacity = n;
//		top = 0;
//	}
//
//	void Push(int x)
//	{
//		// ...扩容
//		a[top++] = x;
//	}
//
//	int Top()
//	{
//		return a[top - 1];
//	}
//
//	void Destroy()
//	{
//		free(a);
//		a = nullptr;
//		top = capacity = 0;
//	}
//
//
//private:	
//	// 成员变量
//
//	int* a;
//
//	size_t capacity;
//	
//	size_t top;
//
//}; // 分号不能省略
//
//int main()
//{
//	Stack st; st.Init();
//
//	st.Push(1);
//	st.Push(2);
//
//	cout << st.Top() << endl;
//	
//	st.Destroy();
//	
//	
//
//	return 0;
//}

//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//private:
//	// 为了区分成员变量，⼀般习惯上成员变量
//	// 会加⼀个特殊标识，如_ 或者 m开头
//	int _year; // year_ m_year
//	int _month;
//	int _day;
//};
//int main()
//{
//	Date d;
//	d.Init(2024, 3, 31);
//
//	return 0;
//}

//typedef struct ListNodeC
//{
//	struct ListNodeC* next;
//	int val;
//}LTNode;
//
//struct ListNodeCPP
//{
//	void Init(int x = 0)
//	{
//		next = nullptr;
//		val = x;
//	}
//	ListNodeCPP* next;
//	int val;
//};
//
//int main()
//{
//	LTNode nc;
//	ListNodeCPP ncpp;
//
//	ncpp.Init();
//	cout << ncpp.val << endl;	// 0
//
//	return 0;
//}

//class Stack
//{
//public:
//	void Init(int n = 4)
//	{
//		a = (int*)malloc(sizeof(int) * n);
//		capacity = n;
//		top = 0;
//	}
//	void Push(int x)
//	{
//		// ...扩容
//		a[top++] = x;
//	}
//	int Top()
//	{
//		return a[top - 1];
//	}
//	void Destroy()
//	{
//		free(a);
//		a = nullptr;
//		top = capacity = 0;
//	}
//private:
//	int* a;
//	size_t capacity;
//	size_t top;
//};
//
//int main()
//{
//	Stack st; 
//	
//	//成员函数都是public权限（可以访问）
//	st.Init();
//	st.Push(1);
//	st.Push(2);
//	cout << st.Top() << endl;
//	st.Destroy();
//
//	//成员变量都是private权限（不可以访问）
//	st.a = nullptr; //
//	st.capacity = 0; //error C2248: “Stack::capacity”: 无法访问 private 成员(在“Stack”类中声明)
//	st.top = 0; //error C2248: “Stack::top”: 无法访问 private 成员(在“Stack”类中声明)
//
//	return 0;
//}

//class Stack
//{
//public:
//	void Init(int n = 4);
//
//private:
//	int* a;
//	int capacity;
//	int top;
//};
//
////正确写法：声明和定义分离，需要指定类域
//void Stack::Init(int n)
//{
//	a = (int*)malloc(sizeof(int) * n);
//	capacity = n;
//	top = 0;
//}
//
//int main()
//{
//	Stack st;
//	st.Init();
//
//	return 0;
//}

//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year << "/" << _month << "/" << _day << endl;
//	}
//private:
//	// 这⾥只是声明，没有开空间
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	// Date类实例化出对象d1和d2
//	Date d1, d2;
//
//	d1.Init(2025, 2, 28);
//	d1.Print();
//
//	d2.Init(2025, 3, 31);
//	d2.Print();
//
//	return 0;
//}

// 计算⼀下A/B/C实例化的对象是多大？

//既有成员函数，又有成员变量
//

//class Date
//{
//public:
//	// void Init(Date* const this, int year, int month, int day)
//	void Init(int year, int month, int day)
//	{
//		// 编译报错：error C2106: “=”: 左操作数必须为左值
//		// this = nullptr;
//		// this->_year = year;
//		this->_year = year;
//		this->_month = month;
//		this->_day = day;
//	}
//	void Print()
//	{
//		cout << this->_year << "/" << this->_month << "/" << this->_day << endl;
//	}
//private:
//	// 这⾥只是声明，没有开空间
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1, d2;
//
//	// d1.Init(&d1, 2025, 3, 9)
//	d1.Init(2025,3,9);
//	// d2.Init(&d1, 2005, 8, 23)
//	d2.Init(2005,8,23);
//
//	// d1.Print(&d1)
//	d1.Print();
//	// d2.Print(&d2)
//	d2.Print();
//
//	return 0;
//}


#include<iostream>
#include<assert.h>

using namespace std;

typedef int STDataType;

class Stack
{
public:
	//成员函数

	//1.初始化
	void Init(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (_a == nullptr)
		{
			perror("malloc failed!");
			return;
		}
		_top = 0;
		_capacity = n;
	}

	//2.入栈
	void Push(STDataType x)
	{
		//判断是否需要扩容
		if (_capacity == _top)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
			//判断realloc是否成功申请空间
			if (tmp == nullptr)
			{
				perror("relloc failed!");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		//插入元素
		_a[_top++] = x;
	}

	//3.出栈
	void Pop()
	{
		assert(_top > 0); //top=0时栈中恰好没有元素
		_top--;
	}

	//4.获取栈顶元素
	STDataType Top()
	{
		assert(_top > 0);
		return _a[_top - 1];
	}

	//5.获取栈中有效元素的个数
	int Size()
	{
		return _top;
	}

	//6.检测栈是否为空
	bool Empty()
	{
		return _top == 0;
	}

	//7.销毁栈
	void Destroy()
	{
		free(_a);
		_a = nullptr;
		_capacity = _top = 0;
	}

private:
	//成员变量
	STDataType* _a;
	int _top;		//栈顶
	int _capacity;	//容量
};

//测试
int main()
{
	Stack s;
	s.Init();

	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);

	while (!s.Empty())
	{
		cout << s.Top() << endl;
		s.Pop();
	}

	s.Destroy();

	return 0;
}